// 版权所有2009 Go作者。版权所有。
// 此源代码的使用受BSD样式
// 许可证的约束，该许可证可以在许可证文件中找到。

// 开始：构建！windows&&！计划9 
// /+建造！窗户，！计划9 

package syslog

import (
	"errors"
	"fmt"
	"log"
	"net"
	"os"
	"strings"
	"sync"
	"time"
)

// 优先级是syslog工具和
// 严重性的组合。例如，LOG|U ALERT | LOG|FTP从FTP设备发送一条警报严重性
// 消息。默认严重性为LOG_EMERG；
// 默认工具是LOG\u KERN。
type Priority int

const severityMask = 0x07
const facilityMask = 0xf8

const (
	// 严重性。

	// From/usr/include/sys/syslog.h。
	// 这些在Linux、BSD和OS X上都是相同的。
	LOG_EMERG Priority = iota
	LOG_ALERT
	LOG_CRIT
	LOG_ERR
	LOG_WARNING
	LOG_NOTICE
	LOG_INFO
	LOG_DEBUG
)

const (
	// 设施。

	// 来自/usr/include/sys/syslog.h。
	// 这些在Linux、BSD和OS X上的日志FTP之前是相同的。
	LOG_KERN Priority = iota << 3
	LOG_USER
	LOG_MAIL
	LOG_DAEMON
	LOG_AUTH
	LOG_SYSLOG
	LOG_LPR
	LOG_NEWS
	LOG_UUCP
	LOG_CRON
	LOG_AUTHPRIV
	LOG_FTP
	_ // 未使用的
	_ // 未使用的
	_ // 未使用的
	_ // 未使用的
	LOG_LOCAL0
	LOG_LOCAL1
	LOG_LOCAL2
	LOG_LOCAL3
	LOG_LOCAL4
	LOG_LOCAL5
	LOG_LOCAL6
	LOG_LOCAL7
)

// 写入程序连接到系统日志服务器。
type Writer struct {
	priority Priority
	tag      string
	hostname string
	network  string
	raddr    string

	mu   sync.Mutex // guards conn 
	conn serverConn
}

// 此接口和单独的syslog_unix.go文件适用于
// 由gccgo实现的Solaris支持。在Solaris上，您不能简单地打开到syslog守护进程的TCP连接。gccgo 
// 源代码有一个syslog_solaris.go文件，该文件将unixSyslog实现为
// 返回一个满足此接口的类型，并简单地调用C 
// 库syslog函数。
type serverConn interface {
	writeString(p Priority, hostname, tag, s, nl string) error
	close() error
}

type netConn struct {
	local bool
	conn  net.Conn
}

// New建立到系统日志守护程序的新连接。对返回的写入程序的每次写入都会发送一条日志消息，其中包含给定的
// 优先级（系统日志功能和严重性的组合）和
// 前缀标记。如果标记为空，则使用os.Args[0]。
func New(priority Priority, tag string) (*Writer, error) {
	return Dial("", "", priority, tag)
}

// 拨号通过连接到指定网络上的
// 地址raddr建立到日志守护程序的连接。每次写入返回的
// writer都会发送一条日志消息，其中包含设备和严重性
// （来自优先级）和标记。如果标记为空，则使用os.Args[0]。
// 如果网络为空，拨号将连接到本地系统日志服务器。
// 否则，请参阅net.Dial文档以了解网络和raddr的有效值
// 。
func Dial(network, raddr string, priority Priority, tag string) (*Writer, error) {
	if priority < 0 || priority > LOG_LOCAL7|LOG_DEBUG {
		return nil, errors.New("log/syslog: invalid priority")
	}

	if tag == "" {
		tag = os.Args[0]
	}
	hostname, _ := os.Hostname()

	w := &Writer{
		priority: priority,
		tag:      tag,
		hostname: hostname,
		network:  network,
		raddr:    raddr,
	}

	w.mu.Lock()
	defer w.mu.Unlock()

	err := w.connect()
	if err != nil {
		return nil, err
	}
	return w, err
}

// connect连接到syslog服务器。
// 必须在持有w.mu的情况下调用它。
func (w *Writer) connect() (err error) {
	if w.conn != nil {
		// ignore err from close，无论如何继续是有意义的
		w.conn.close()
		w.conn = nil
	}

	if w.network == "" {
		w.conn, err = unixSyslog()
		if w.hostname == "" {
			w.hostname = "localhost"
		}
	} else {
		var c net.Conn
		c, err = net.Dial(w.network, w.raddr)
		if err == nil {
			w.conn = &netConn{
				conn:  c,
				local: w.network == "unixgram" || w.network == "unix",
			}
			if w.hostname == "" {
				w.hostname = c.LocalAddr().String()
			}
		}
	}
	return
}

// Write向syslog守护进程发送日志消息。
func (w *Writer) Write(b []byte) (int, error) {
	return w.writeAndRetry(w.priority, string(b))
}

// 关闭与syslog后台程序的连接。
func (w *Writer) Close() error {
	w.mu.Lock()
	defer w.mu.Unlock()

	if w.conn != nil {
		err := w.conn.close()
		w.conn = nil
		return err
	}
	return nil
}

// Emerg记录一条严重性为LOG_Emerg的消息，忽略传递给New的严重性
// 。
func (w *Writer) Emerg(m string) error {
	_, err := w.writeAndRetry(LOG_EMERG, m)
	return err
}

// 警报记录一条带有严重性日志\u警报的消息，忽略严重性
// 传递给New。
func (w *Writer) Alert(m string) error {
	_, err := w.writeAndRetry(LOG_ALERT, m)
	return err
}

// Crit记录一条严重性为LOG\u Crit的消息，忽略传递给New的严重性
// 消息。
func (w *Writer) Crit(m string) error {
	_, err := w.writeAndRetry(LOG_CRIT, m)
	return err
}

// Err记录一条严重性为LOG_Err的消息，忽略传递给New的严重性
// 消息。
func (w *Writer) Err(m string) error {
	_, err := w.writeAndRetry(LOG_ERR, m)
	return err
}

// 警告记录一条带有严重性日志\u警告的消息，忽略
// 严重性传递给新用户。
func (w *Writer) Warning(m string) error {
	_, err := w.writeAndRetry(LOG_WARNING, m)
	return err
}

// 通知记录一条带有严重性日志\u通知的消息，忽略传递给New的
// 严重性。
func (w *Writer) Notice(m string) error {
	_, err := w.writeAndRetry(LOG_NOTICE, m)
	return err
}

// Info使用严重性日志信息记录消息，忽略传递给New的严重性
// 。
func (w *Writer) Info(m string) error {
	_, err := w.writeAndRetry(LOG_INFO, m)
	return err
}

// 调试记录严重性为LOG\u Debug的消息，忽略严重性
// 传递给New。
func (w *Writer) Debug(m string) error {
	_, err := w.writeAndRetry(LOG_DEBUG, m)
	return err
}

func (w *Writer) writeAndRetry(p Priority, s string) (int, error) {
	pr := (w.priority & facilityMask) | (p & severityMask)

	w.mu.Lock()
	defer w.mu.Unlock()

	if w.conn != nil {
		if n, err := w.write(pr, s); err == nil {
			return n, err
		}
	}
	if err := w.connect(); err != nil {
		return 0, err
	}
	return w.write(pr, s)
}

// write生成并写入syslog格式的字符串。
// 格式如下：<PRI>时间戳主机名标记[PID]：MSG 
func (w *Writer) write(p Priority, msg string) (int, error) {
	// 确保它以\n 
	nl := ""
	if !strings.HasSuffix(msg, "\n") {
		nl = "\n"
	}

	err := w.conn.writeString(p, w.hostname, w.tag, msg, nl)
	if err != nil {
		return 0, err
	}
	// 结尾注意：返回输入的长度，而不是Fprintf打印的
	// 字节数，因为它的行为必须类似于
	// io.Writer。
	return len(msg), nil
}

func (n *netConn) writeString(p Priority, hostname, tag, msg, nl string) error {
	if n.local {
		// 与下面的网络表单相比，变化为：
		// 1。使用time.Stamp而不是time.rfc339。
		// 2。从Fprintf中删除主机名字段。
		timestamp := time.Now().Format(time.Stamp)
		_, err := fmt.Fprintf(n.conn, "<%d>%s %s[%d]: %s%s",
			p, timestamp,
			tag, os.Getpid(), msg, nl)
		return err
	}
	timestamp := time.Now().Format(time.RFC3339)
	_, err := fmt.Fprintf(n.conn, "<%d>%s %s %s[%d]: %s%s",
		p, timestamp, hostname,
		tag, os.Getpid(), msg, nl)
	return err
}

func (n *netConn) close() error {
	return n.conn.Close()
}

// NewLogger创建一个日志。其输出以指定优先级写入
// 系统日志服务的日志记录器，是
// 系统日志设施和严重性的组合。logFlag参数是标志
// 传递给log.New以创建记录器的集合。
func NewLogger(p Priority, logFlag int) (*log.Logger, error) {
	s, err := New(p, "")
	if err != nil {
		return nil, err
	}
	return log.New(s, "", logFlag), nil
}
